#include "Canasta.h"
#include "HuevoBlanco.h"
#include "HuevoCodorniz.h"
#include "HuevoReloj.h"
#include "HuevoPoche.h"

#define CNT_TIPO_HUEVOS 4
#define HUEVO_BLANCO 1 
#define HUEVO_CODORNIZ 2 
#define HUEVO_POCHE 3
#define HUEVO_RELOJ 4

using namespace TP::Juego::Arena::Utilidades;

Canasta::Canasta() {
    _rol = new Rol(ROL_CANASTA, ROL_CANASTA);
    _vida = VIDA_CANASTA;
    _posicionAtaque = NULL;
    _seed = CNT_TIPO_HUEVOS;
}

Canasta::~Canasta() {
	if (NULL != this->_posicionAtaque)
		delete this->_posicionAtaque;
}

Huevo* Canasta::getHuevo() {
	
    /* La posicion de ataque es la posicion inicial con la que se configuran los
     * huevos al entregarlos.
     */
    
    Huevo* huevo = NULL;
    double huevoALanzar = drand48();

    
    if(huevoALanzar < 0.2)  huevo = new HuevoBlanco();
    else if (huevoALanzar >= 0.2 && huevoALanzar < 0.5) huevo = new HuevoCodorniz();
    else if (huevoALanzar >= 0.5 && huevoALanzar < 0.8) huevo = new HuevoPoche();
    else if (huevoALanzar >= 0.8) huevo = new HuevoReloj();
//    switch (_seed)
//    {
//        case HUEVO_BLANCO:
//            huevo = new HuevoBlanco();
//            break;
//        case HUEVO_CODORNIZ:
//            huevo = new HuevoCodorniz();
//            break;
//        case HUEVO_POCHE:
//            huevo = new HuevoPoche();
//            break;
//        case HUEVO_RELOJ:
//            huevo = new HuevoReloj();
//            break;
//    }
    
    _seed--;
    
    if (0 == _seed)
        _seed = CNT_TIPO_HUEVOS;
    
    huevo->setTrayectoria(new Trayectoria(this->getPosicionAtaque(),
                    new Vector2D(0.0, 0.0), new Vector2D(0.0, 0.0)));
    return huevo;
}

Posicion* Canasta::setPosicionAtaque(Posicion* pPosicion) throw (Excepcion&) {
	if (!pPosicion)
		throw Excepcion("pPosicion no puede ser NULL");

	if (NULL != this->_posicionAtaque)
		delete this->_posicionAtaque;

	this->_posicionAtaque = pPosicion;
	return pPosicion;
}

Utilidad* Canasta::clonar() {
	// Instancio y configuro el clon.
	Canasta* canasta = new Canasta();
	canasta->_posicion = NULL;
	if (NULL != this->_posicion) {
		canasta->_posicion = new Posicion();
		canasta->_posicion->deElementoXML(_posicion->aElementoXML());
	}
	canasta->_posicionAtaque = NULL;
	if (NULL != this->_posicionAtaque) {
		canasta->_posicionAtaque = new Posicion();
		canasta->_posicionAtaque->deElementoXML(_posicionAtaque->aElementoXML());
	}
	// configuro los atributos nativos.
	//canasta->_puntaje = this->_puntaje;
	canasta->_vida = this->_vida;
	return new Canasta();
}

Posicion* Canasta::getPosicionAtaque() {
	// Clono la posicion de ataque.
	Posicion* aux = new Posicion();
	aux->deElementoXML(this->_posicionAtaque->aElementoXML());
        aux->X(this->_posicionAtaque->X()+5);
	return aux;
}

double Canasta::getRadio() {
	return 0;
}

int Canasta::getPuntosDestruccion() {
	return 0;
}

TiXmlElement* Canasta::aElementoXML() {
	TiXmlElement* elemento = Utilidad::aElementoXML();

	if (NULL != this->_posicionAtaque)
		elemento->LinkEndChild(this->_posicionAtaque->aElementoXML());
	else
		elemento->LinkEndChild(new TiXmlElement("NULL"));

	return elemento;
}

void Canasta::deElementoXML(TiXmlElement* pElemento) {
	if (strcmp(pElemento->Value(), _rol->Nombre().c_str()) == 0) {

		// Hidrato los atributos nativos.
		pElemento->Attribute("vida", &_vida);

		// Hidrato la posicion.
		this->_posicion = NULL;
		if ("NULL" != pElemento->FirstChildElement()->ValueTStr()) {
			this->setPosicion(new Posicion());
			this->getPosicion()->deElementoXML(pElemento->FirstChildElement());
		}

		// Hidrato la posicion de ataque.
		this->_posicionAtaque = NULL;
		if ("NULL" != pElemento->FirstChildElement()->NextSiblingElement(
				)->ValueTStr()) {
			this->_posicionAtaque = new Posicion();
			this->_posicionAtaque->deElementoXML(pElemento->FirstChildElement(
					)->NextSiblingElement());
		}
	}
}